I don't think it's a good idea to create a TTL that's equal to UpdateInterval, because there may be some hiccups with metamorph service, in which case we can loose data.

Also, this TTL is doing nothing when we're giving a hash to the method (see my next comment)

I would choose either:

1. A very long const TTL in order not to clear records that for some reason were never queried.
2. No TTL at all and periodical clearing cache (what I think we have currently already implemented with clearCache on every update.

We're only passing in the ttl when we're using the regular Set, otherwise, with HSet there's not TTL

This hash is optional, as I understand, but because of that, in every method we have to check if hash != nil. Also, currently, we're always using a hash and never access the general store.

What do you think about defining a list of allowedHashSets (e.g. in cache.go) with hashes of sets that we can use and only allow to use those HSets, instead of allowing using the general store? Or even better - just define those allowable sets in an Enum, which we can use everywhere in code.

Then, you could also check if given hash exists in allowedHashSets (or enum) and if not - return an ErrNotAllowedSet or something like that. You wouldn't have to retrieve values in a different way depending on whether the hash exists or not and it would not have to be a pointer.

Currently, we're only saving and returning a []byte type from the store. One idea for improvement would be to make this store generic and use jsons. Example:

type RedisStore struct {
	// ...
}

func (r *RedisStore) Get[T any](key string) (T, error) {
	val, err := r.client.Get(r.ctx, key)
	if err != nil {
		return result, err
	}

	// Assume Redis values are stored as JSON strings
	var result T
	err = json.Unmarshal([]byte(val), &result)
	if err != nil {
		return result, ErrFailedToParseValue
	}

	return result, nil
}

func (r *RedisStore) Set[T any](key string, value T) error {
	// Marshal the value into JSON
	data, err := json.Marshal(value)
	if err != nil {
		return ErrFailedToMarshall
	}

	err = r.client.Set(r.ctx, key, string(data))
	if err != nil {
		return ErrCacheFailedToSet
	}

	return nil
}

Maybe I'm going too far and this is not required, or maybe it's for another task, but I'm throwing the idea here.

WDYT? @boecklim @arkadiuszos4chain @pawellewandowski98